This is the EDA for 2018 KDD CUP¶
Checker¶
In [3]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
path='../ml_dataset/2018_kdd_cup_dataset/'
pd.read_csv(path+"beijing_17_18_aq.csv")
Out[3]:
In [4]:
pd.read_csv(path+"beijing_201802_201803_aq.csv")
Out[4]:
In [5]:
beji_aqi_sta=pd.read_csv(path+"Beijing_AirQuality_Stations_en.xlsx")
In [6]:
Lodon_aqi=pd.read_csv(path+"London_historical_aqi_forecast_stations_20180331.csv")
Lodon_aqi
Out[6]:
In [7]:
Lodon_aqi.isnull().sum()
Out[7]:
In [8]:
#import xlrd
import csv
import pandas as pd
def xlsx_to_csv_pd():
data_xls = pd.read_excel(path+'Beijing_AirQuality_Stations_en.xlsx', index_col=0)
data_xls.to_csv('Beijing_AirQuality_Stations.csv', encoding='utf-8')
if __name__ == '__main__':
xlsx_to_csv_pd()
In [9]:
pd.read_csv(path+"London_historical_aqi_other_stations_20180331.csv")
Out[9]:
Geograhy
In [10]:
pd.read_csv(path+"London_grid_weather_station.csv")
Out[10]:
In [11]:
pd.read_csv(path+"Beijing_grid_weather_station.csv")
Out[11]:
In [12]:
pd.read_csv(path+"London_grid_weather_station.csv")
Out[12]:
In [13]:
pd.read_csv(path+"Beijing_historical_meo_grid.csv")
Out[13]:
From here is the geographic EDA¶
The station in Beijin¶
In [14]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
In [15]:
beijingAqCsv = pd.read_csv('../ml_dataset/2018_kdd_cup_dataset/beijing_17_18_aq.csv')
air_station_beij = beijingAqCsv.groupby("stationId", sort=False)
In [17]:
beijingAqCsv_sta = pd.read_csv('Beijing_AirQuality_Stations.csv')
In [18]:
beijingAqCsv_sta
Out[18]:
In [19]:
import folium
In [20]:
list(air_station_beij.groups.keys())
Out[20]:
In [21]:
location_beijin={}
In [22]:
for i in range(0,len(beijingAqCsv_sta)):
temp=beijingAqCsv_sta.iloc[i,:]
if temp['Pollutant Species'] in list(air_station_beij.groups.keys()):
location_beijin[temp['Pollutant Species']]=temp.values[1:].astype(float).tolist()[::-1]
In [23]:
location_beijin
Out[23]:
In [24]:
#del temp
temp=beijingAqCsv_sta.loc[beijingAqCsv_sta['Pollutant Species']==list(air_station_beij.groups.keys())[0]].iloc[:,1:].values[0]
In [25]:
temp
Out[25]:
In [26]:
temp=temp.astype(float).tolist()
In [27]:
temp=temp[::-1]
In [28]:
map_beijin_1 = folium.Map(location=temp, zoom_start=9)
In [29]:
for key in location_beijin:
folium.Marker(location=location_beijin[key]).add_to(map_beijin_1)
map_beijin_1
Out[29]:
In [30]:
temp=beijingAqCsv_sta.loc[beijingAqCsv_sta['Pollutant Species']==list(air_station_beij.groups.keys())[0]].iloc[:,1:].values[0]
temp=temp.astype(float).tolist()
temp=temp[::-1]
map_beijin_1 = folium.Map(location=temp, zoom_start=9,tiles='Stamen Terrain')
for key in location_beijin:
folium.Marker(location=location_beijin[key]).add_to(map_beijin_1)
map_beijin_1
Out[30]:
beijing grid¶
In [31]:
beijing_grid_sta=pd.read_csv(path+"Beijing_historical_meo_grid.csv")
In [32]:
beijing_grid_sta
Out[32]:
In [33]:
beiji_grid={}
In [34]:
#faster in kmeans
from sklearn.cluster import MiniBatchKMeans
kmeans = MiniBatchKMeans(n_clusters=len(location_beijin), batch_size=1000).fit(beijing_grid_sta[['latitude','longitude']])
beijing_grid_sta.loc[:, 'label'] = kmeans.labels_
In [35]:
map_beijing_2 = folium.Map(location=beijing_grid_sta[['latitude','longitude']].iloc[0].values.tolist(),
zoom_start=9)
for label in kmeans.cluster_centers_:
folium.Marker(location=[label][0]).add_to(map_beijing_2)
map_beijing_2
Out[35]:
In [36]:
map_beijing_2 = folium.Map(location=beijing_grid_sta[['latitude','longitude']].iloc[0].values.tolist(),
zoom_start=9,tiles='Stamen Terrain')
for label in kmeans.cluster_centers_:
folium.Marker(location=[label][0]).add_to(map_beijing_2)
map_beijing_2
Out[36]:
In [37]:
map_heat_ground_beijing_1 = folium.Map(location=beijing_grid_sta[['latitude','longitude']].iloc[0].values.tolist(),
zoom_start =6, attr='USGS style')
In [38]:
import folium
from folium import plugins
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import os
#m = folium.Map([,], control_scale = True, zoom_start=11)
#plugins.HeatMap(data, radius = 20, min_opacity = 0.1, max_val = 50,gradient={.2: 'blue', .5: 'lime', 1: 'red'}).add_to(m)
In [39]:
lats = np.array([float(row['latitude'])for index, row in beijing_grid_sta.iloc[:1000].iterrows() ])
In [40]:
lats
Out[40]:
In [41]:
#prevent too large
lats = np.array([float(row['latitude'])for index, row in beijing_grid_sta.iloc[:10000].iterrows() ])
lons = np.array([float(row['longitude']) for index, row in beijing_grid_sta.iloc[:10000].iterrows() ])
mag = np.array([float(row['temperature']) for index, row in beijing_grid_sta.iloc[:10000].iterrows() ])
time=np.array([row['utc_time'] for index, row in beijing_grid_sta.iloc[:10000].iterrows() ])
data=np.vstack((lats,lons,mag,time))
data=data.T
data[:,:3]
Out[41]:
In [42]:
set(time)
Out[42]:
In [43]:
list(set(time))
Out[43]:
In [44]:
init_=[]
for i in range(0,len(set(time))):
init_.append([])
init_
Out[44]:
In [45]:
for i in range(0,len(data)):
index_value=list(set(time)).index(data[i,3])
init_[index_value].append(data[i,:3].astype(float).tolist())
In [46]:
len(init_)
Out[46]:
In [47]:
# List comprehension to make out list of lists
colormap ={.4: 'blue', .65: 'lime', 1: 'red'}
# Plot it on the map
hm = plugins.HeatMapWithTime(init_,radius = 15)
hm.add_to(map_heat_ground_beijing_1)
#plugins.HeatMap(init_, radius = 20,gradient=colormap).add_to(map_heat_ground_1_2)
# Display the map
map_heat_ground_beijing_1
Out[47]:
The station in London¶
In [48]:
LondonAqCsv_sta = pd.read_csv(path+'London_AirQuality_Stations.csv')
In [49]:
LondonAqCsv_sta
Out[49]:
In [50]:
location_Lodon={}
for i in range(0,len(LondonAqCsv_sta)):
temp_name=LondonAqCsv_sta['Unnamed: 0'].iloc[i]
temp_Latitude=LondonAqCsv_sta['Latitude'].iloc[i]
temp_Longitude=LondonAqCsv_sta['Longitude'].iloc[i]
location_Lodon[temp_name]=[temp_Latitude,temp_Longitude]
In [51]:
location_Lodon
Out[51]:
In [52]:
#del temp
col_list=['Latitude','Longitude']
temp_pd=LondonAqCsv_sta[col_list]
In [53]:
temp_pd.iloc[0].values.tolist()
Out[53]:
In [54]:
map_london_1 = folium.Map(location=temp_pd.iloc[0].values.tolist(), zoom_start=9)
In [55]:
for key in location_Lodon:
folium.Marker(location=location_Lodon[key]).add_to(map_london_1)
map_london_1
Out[55]:
In [56]:
map_london_1= folium.Map(location=temp_pd.iloc[0].values.tolist(), zoom_start=9,tiles='Stamen Terrain')
In [57]:
for key in location_Lodon:
folium.Marker(location=location_Lodon[key]).add_to(map_london_1)
map_london_1
Out[57]:
Adding Time series EDA¶
In [58]:
beji_aqi_2018=pd.read_csv(path+"beijing_201802_201803_aq.csv")
beji_aqi_2017_2018=pd.read_csv(path+"beijing_17_18_aq.csv")
beji_aqi_summary=pd.concat([beji_aqi_2018,beji_aqi_2017_2018],axis=0).sort_values(by=['utc_time'])
beji_aqi_summary=beji_aqi_summary.set_index([list(range(0,len(beji_aqi_summary)))])
beji_aqi_summary
Out[58]:
In [59]:
len(beji_aqi_summary.groupby(['utc_time']))
Out[59]:
In [61]:
beji_aqi_summary.isnull().sum()/len(beji_aqi_summary)
Out[61]:
In [63]:
import gc
gc.collect()
for key in beji_aqi_summary.groupby(['stationId']).groups:
plt.clf()
plt.figure(figsize=(20,10))
plt.title(key,fontsize=18)
temp_data=beji_aqi_summary.iloc[beji_aqi_summary.groupby(['stationId']).groups[key]]
plt.plot(temp_data['PM2.5'])
#plt.xtickets(temp_data['utc_time'], fontsize=15)
plt.show()
In [64]:
#missing values ratio
beijin_missing_pm25=[]
for key in beji_aqi_summary.groupby(['stationId']).groups:
temp_data=beji_aqi_summary.iloc[beji_aqi_summary.groupby(['stationId']).groups[key]]
ratio=float(temp_data['PM2.5'].isnull().sum()/len(temp_data))
if ratio > 0.15:
print(key)
beijin_missing_pm25.append(key)
In [65]:
temp=beijingAqCsv_sta.loc[beijingAqCsv_sta['Pollutant Species']==list(air_station_beij.groups.keys())[0]].iloc[:,1:].values[0]
temp=temp.astype(float).tolist()
temp=temp[::-1]
map_beijin_1 = folium.Map(location=temp, zoom_start=9,tiles='Stamen Terrain')
for key in location_beijin:
if key in beijin_missing_pm25:
folium.Marker(location=location_beijin[key],
popup='Missing value ratio > 0.15 Location',
icon=folium.Icon(color='red',icon='info-sign')).add_to(map_beijin_1)
else:
folium.Marker(location=location_beijin[key]).add_to(map_beijin_1)
map_beijin_1
Out[65]:
Add grid¶
In [66]:
beijing_grid_sta=pd.read_csv(path+"Beijing_historical_meo_grid.csv")
In [67]:
beijing_grid_sta.columns
Out[67]:
In [68]:
beijing_grid_sta.iloc[beijing_grid_sta.groupby(['stationName']).groups['beijing_grid_648'][0],1:3].values
Out[68]:
In [69]:
beijing_grid_sta
Out[69]:
In [70]:
len(beijing_grid_sta.groupby(['utc_time']))
Out[70]:
In [72]:
beiji_grid
Out[72]:
In [73]:
from sklearn.cluster import MiniBatchKMeans
kmeans = MiniBatchKMeans(n_clusters=len(location_beijin), batch_size=1000).fit(beijing_grid_sta[['latitude','longitude']])
beijing_grid_sta.loc[:, 'label'] = kmeans.labels_
In [74]:
for label in kmeans.cluster_centers_:
folium.Marker(location=[label][0],popup='grid point',
icon=folium.Icon(color='green',icon='info-sign')).add_to(map_beijin_1)
map_beijin_1
Out[74]:
In [75]:
#wheather
len(beijing_grid_sta.groupby(['stationName']).groups)
Out[75]:
In [76]:
len(beijing_grid_sta)
Out[76]:
In [77]:
#feature testing
#from sklearn.linear_model import LinearRegression
#for keys in
#LinearRegression()
the overlap part of time slice¶
In [78]:
a = set(beji_aqi_summary.groupby(["utc_time"]).groups.keys())
b=set(beijing_grid_sta.groupby(["utc_time"]).groups.keys())
In [79]:
import matplotlib_venn as venn
common_time_list=list(set(a).intersection(b))
plt.title("Common time slice")
venn.venn2([a,b],
set_labels=("time slice in AQI station"," time slice in weather grid station"))
plt.show()
we need to ensure the time is continue or not
In [80]:
exclusive=(a ^ b)
beji_aqi_summary_copy=beji_aqi_summary.copy() #a
beijing_grid_sta_copy=beijing_grid_sta.copy() #b
first_time_1=1
first_time_2=1
contaniner_1=[]
contaniner_2=[]
for timeslice in exclusive:
if timeslice in a:
if first_time_1 is 1:
first_time_1=0
contaniner_1=list(beji_aqi_summary.groupby(["utc_time"]).groups[timeslice])
else:
contaniner_1=contaniner_1+list(beji_aqi_summary.groupby(["utc_time"]).groups[timeslice])
if timeslice in b:
if first_time_2 is 1:
first_time_2=0
contaniner_2=list(beijing_grid_sta.groupby(["utc_time"]).groups[timeslice])
else:
contaniner_2=contaniner_2+list(beijing_grid_sta.groupby(["utc_time"]).groups[timeslice])
contaniner_1.sort()
contaniner_2.sort()
In [81]:
beji_aqi_summary_copy.drop(beji_aqi_summary_copy.index[contaniner_1]).sort_values(by=['utc_time'])
Out[81]:
In [82]:
len(beji_aqi_summary_copy.drop(beji_aqi_summary_copy.index[contaniner_1]).groupby(['utc_time']).groups)
Out[82]:
In [83]:
len(beijing_grid_sta_copy.drop(beijing_grid_sta_copy.index[contaniner_2]).groupby(['utc_time']).groups)
Out[83]:
In [84]:
len(beji_aqi_summary_copy)
Out[84]:
In [85]:
len(contaniner_1)/35
Out[85]:
In [86]:
len(beji_aqi_summary_copy.groupby(['stationId']).groups)
Out[86]:
In [87]:
len(beji_aqi_summary_copy.drop(beji_aqi_summary_copy.index[contaniner_1]).groupby(['stationId']).groups)
Out[87]:
In [88]:
len(beji_aqi_summary_copy.drop(beji_aqi_summary_copy.index[contaniner_1]))/35
Out[88]:
In [89]:
len(beji_aqi_summary_copy.drop(beji_aqi_summary_copy.index[contaniner_1]))/len(common_time_list)
Out[89]:
There might be some inconsistency!!
Seems like start from 2017-01-01 14:00:00 to 2018-03-27 05:00:00
In [90]:
(len(common_time_list)-10-6)%24
Out[90]:
OOps!! the time slice is not continue, there miss some time slice in the data, because module should be 0
Autocorrealtion plot by station¶
In [91]:
from pandas.plotting import autocorrelation_plot
In [174]:
beji_aqi_summary_copy=beji_aqi_summary_copy.sort_values(by=["utc_time"])
In [189]:
from matplotlib import pyplot,rcParams
col=['PM2.5','PM10','NO2','CO','O3','SO2']
def autocorr(x, t=1):
#if
np.corrcoef(np.array([x[0:len(x)-t], x[t:len(x)]]))
index_set=beji_aqi_summary_copy.groupby(['stationId']).groups
rcParams.update({'font.size': 24})
for keys in index_set.keys():
#plt.plot(autocorr(beji_aqi_summary_copy[item].fillna(0).values, t=1))
print(keys)
plt.clf()
plt.figure(figsize=(40,25))
for item in col:
autocorrelation_plot(beji_aqi_summary_copy[item].fillna(0).iloc[index_set[keys]],label=item)
plt.legend(loc='upper right')
pyplot.show()
#plt.show()
Correaltion plot by station¶
In [124]:
import seaborn as sns
In [127]:
for keys in index_set.keys():
#plt.plot(autocorr(beji_aqi_summary_copy[item].fillna(0).values, t=1))
print(keys)
plt.clf()
plt.figure(figsize=(10,10))
corr = beji_aqi_summary_copy[col].fillna(0).iloc[index_set[keys]].corr()
sns.heatmap(corr)
pyplot.show()
London¶
In [136]:
pd.read_csv(path+"London_historical_aqi_forecast_stations_20180331.csv").iloc[:,1:]
Out[136]:
In [137]:
pd.read_csv(path+"London_historical_aqi_other_stations_20180331.csv").iloc[:,:5]
Out[137]:
In [138]:
London_sta=pd.read_csv(path+"London_historical_aqi_forecast_stations_20180331.csv").iloc[:,1:]
London_sta_other=pd.read_csv(path+"London_historical_aqi_other_stations_20180331.csv").iloc[:,:5]
In [139]:
London_sta_other.loc[~London_sta_other["Station_ID"].isnull(),:]
Out[139]:
In [140]:
London_sta_other=London_sta_other.loc[~London_sta_other["Station_ID"].isnull(),:]
London_sta_other.columns
#change to lower char
London_sta_other.columns = London_sta_other.columns.str.lower()
London_sta.columns = London_sta.columns.str.lower()
London_sta_other.columns==London_sta.columns
Out[140]:
In [141]:
London_sta
Out[141]:
In [142]:
London_sta_other
Out[142]:
In [143]:
#columnsTitles=["measurementdategmt","station_id"]
London_sta_other.reindex(columns=list(London_sta.columns))
Out[143]:
In [144]:
London_sta_other=London_sta_other.reindex(columns=list(London_sta.columns))
pd.concat([London_sta_other,London_sta],axis=0)
Out[144]:
In [145]:
London_comb=pd.concat([London_sta_other,London_sta],axis=0).sort_values(by=['measurementdategmt'])
London_comb=London_comb.set_index([list(range(0,len(London_comb)))])
In [147]:
London_comb.isnull().sum()/len(London_comb)
Out[147]:
In [149]:
import gc
gc.collect()
for key in London_comb.groupby(['station_id']).groups:
plt.clf()
plt.figure(figsize=(20,10))
plt.title(key,fontsize=18)
temp_data=London_comb.iloc[London_comb.groupby(['station_id']).groups[key]]
plt.plot(temp_data['pm2.5 (ug/m3)'])
#plt.xtickets(temp_data['utc_time'], fontsize=15)
plt.show()
In [150]:
#missing values ratio
London_missing_pm25=[]
for key in London_comb.groupby(['station_id']).groups:
temp_data=London_comb.iloc[London_comb.groupby(['station_id']).groups[key]]
ratio=float(temp_data['pm2.5 (ug/m3)'].isnull().sum()/len(temp_data))
if ratio > 0.15:
print(key)
London_missing_pm25.append(key)
In [151]:
map_london_1= folium.Map(location=temp_pd.iloc[0].values.tolist(), zoom_start=9,tiles='Stamen Terrain')
for key in location_Lodon:
if key in London_missing_pm25:
folium.Marker(location=location_Lodon[key],
popup='Missing value ratio > 0.15 Location',
icon=folium.Icon(color='red',icon='info-sign')).add_to(map_london_1)
else:
folium.Marker(location=location_Lodon[key]).add_to(map_london_1)
map_london_1
Out[151]:
Add grid¶
In [152]:
London_grid_sta=pd.read_csv(path+"London_grid_weather_station.csv")
London_grid_sta
Out[152]:
In [153]:
London_grid_sta_weather=pd.read_csv(path+"London_historical_meo_grid.csv")
London_grid_sta_weather
Out[153]:
In [154]:
import re
def split_time(x):
listofx=re.split('\-| |:',x)
if listofx[3][0]=="0":
num_3=listofx[3][1]
else:
num_3=listofx[3]
if listofx[2][0]=="0":
num_2=listofx[2][1]
else:
num_2=listofx[2]
if listofx[1][0]=="0":
num_1=listofx[1][1]
else:
num_1=listofx[1]
time_word=listofx[0]+"/"+num_1+"/"+num_2+" "+num_3+":"+"00"
return time_word
London_grid_sta_weather["utc_time"].apply(lambda x: split_time(str(x)))
Out[154]:
In [155]:
London_grid_sta_weather["utc_time"]=London_grid_sta_weather["utc_time"].apply(lambda x: split_time(str(x)))
2018/4/1 0:00, format of the measurementdategmt
In [156]:
from sklearn.cluster import MiniBatchKMeans
kmeans = MiniBatchKMeans(n_clusters=len(location_Lodon), batch_size=1000).fit(London_grid_sta_weather[['latitude','longitude']])
London_grid_sta_weather.loc[:, 'label'] = kmeans.labels_
In [157]:
for label in kmeans.cluster_centers_:
folium.Marker(location=[label][0],popup='grid point',
icon=folium.Icon(color='green',icon='info-sign')).add_to(map_london_1)
map_london_1
Out[157]:
the overlap part of time slice¶
In [161]:
a = set(London_comb.groupby(["measurementdategmt"]).groups.keys())
b = set(London_grid_sta_weather.groupby(["utc_time"]).groups.keys())
In [162]:
import matplotlib_venn as venn
common_time_list=list(set(a).intersection(b))
plt.title("Common time slice")
venn.venn2([a,b],
set_labels=("time slice in AQI station"," time slice in weather grid station"))
plt.show()
In [163]:
exclusive=(a ^ b)
London_comb_copy=London_comb.copy() #a
London_grid_sta_weather_copy=London_grid_sta_weather.copy() #b
first_time_1=1
first_time_2=1
contaniner_1=[]
contaniner_2=[]
for timeslice in exclusive:
if timeslice in a:
if first_time_1 is 1:
first_time_1=0
contaniner_1=list(London_comb.groupby(["measurementdategmt"]).groups[timeslice])
else:
contaniner_1=contaniner_1+list(London_comb.groupby(["measurementdategmt"]).groups[timeslice])
if timeslice in b:
if first_time_2 is 1:
first_time_2=0
contaniner_2=list(London_grid_sta_weather.groupby(["utc_time"]).groups[timeslice])
else:
contaniner_2=contaniner_2+list(London_grid_sta_weather.groupby(["utc_time"]).groups[timeslice])
contaniner_1.sort()
contaniner_2.sort()
In [164]:
London_comb.drop(London_comb.index[contaniner_1]).sort_values(by=["measurementdategmt"])
Out[164]:
In [203]:
len(London_comb.drop(London_comb.index[contaniner_1]).groupby(["measurementdategmt"]).groups)
Out[203]:
In [204]:
len(London_grid_sta_weather.drop(London_grid_sta_weather.index[contaniner_2]).groupby(["utc_time"]).groups)
Out[204]:
In [205]:
len(exclusive)
Out[205]:
In [206]:
len(London_comb.groupby(["station_id"]).groups)
Out[206]:
In [207]:
len(London_comb.drop(London_comb.index[contaniner_1]).groupby(["station_id"]).groups)
Out[207]:
In [208]:
len(London_comb.drop(London_comb.index[contaniner_1]))/24
Out[208]:
In [211]:
len(London_comb.drop(London_comb.index[contaniner_1]))/len(common_time_list)
Out[211]:
In [210]:
len(London_grid_sta_weather.drop(London_grid_sta_weather.index[contaniner_2]).groupby(["stationName"]).groups)
Out[210]:
In [177]:
len(contaniner_2)%861
Out[177]:
Seems like from 2017/1/1 0:00 to 2018/3/9 9:00, but AQI station data has some inconsistency
In [178]:
(len(common_time_list)-10)%24
Out[178]:
OOps the time slice is not continuous, that is 0 for module
Autocorrealtion plot by station¶
In [177]:
from pandas.plotting import autocorrelation_plot
In [178]:
London_comb=London_comb.sort_values(by=["measurementdategmt"])
In [191]:
from matplotlib import pyplot
col=['pm2.5 (ug/m3)','pm10 (ug/m3)','no2 (ug/m3)']
def autocorr(x, t=1):
#if
np.corrcoef(np.array([x[0:len(x)-t], x[t:len(x)]]))
index_set=London_comb.groupby(['station_id']).groups
rcParams.update({'font.size': 24})
for keys in index_set.keys():
#plt.plot(autocorr(beji_aqi_summary_copy[item].fillna(0).values, t=1))
print(keys)
plt.clf()
plt.figure(figsize=(40,25))
for item in col:
autocorrelation_plot(London_comb[item].fillna(0).iloc[index_set[keys]],label=item)
plt.legend(loc='upper right')
pyplot.show()
Correaltion plot by station¶
In [176]:
import seaborn as sns
In [181]:
for keys in index_set.keys():
#plt.plot(autocorr(beji_aqi_summary_copy[item].fillna(0).values, t=1))
print(keys)
plt.clf()
plt.figure(figsize=(7,7))
corr = London_comb[col].fillna(0).iloc[index_set[keys]].corr()
sns.heatmap(corr)
pyplot.show()
